home *** CD-ROM | disk | FTP | other *** search
/ Graphics Plus / Graphics Plus.iso / libs / tsipp / tsipp.lha / tsipp3.0a / sippsrc / rendering.cdiff < prev   
Encoding:
Text File  |  1992-11-02  |  13.0 KB  |  490 lines
  1. *** ../../sipp-3.0/libsipp/rendering.c    Sun May  3 08:19:12 1992
  2. --- rendering.c    Wed Oct  7 15:57:45 1992
  3. ***************
  4. *** 46,51
  5.    */
  6.   static bool          show_backfaces;  /* Don't do backface culling */
  7.   static bool          shadows;         /* Calculate shadows */
  8.   static Edge        **y_bucket;        /* Y-bucket for edge lists. */
  9.   static FILE         *image_file;      /* File to store image in      */
  10.                                         /* when rendering into a file. */
  11.  
  12. --- 46,52 -----
  13.    */
  14.   static bool          show_backfaces;  /* Don't do backface culling */
  15.   static bool          shadows;         /* Calculate shadows */
  16. + static bool          reverse_scan;    /* Render scan lines in reverse */
  17.   static Edge        **y_bucket;        /* Y-bucket for edge lists. */
  18.   static FILE         *image_file;      /* File to store image in      */
  19.                                         /* when rendering into a file. */
  20. ***************
  21. *** 226,232
  22.   
  23.               deltay = 1.0 / fabs(deltay);
  24.   
  25. !             if (nderiv > 0) {       
  26.   
  27.                   /*
  28.                    * The edge has positive slope
  29.  
  30. --- 227,234 -----
  31.   
  32.               deltay = 1.0 / fabs(deltay);
  33.   
  34. !             if ((reverse_scan    && nderiv <= 0) ||
  35. !                 ((!reverse_scan) && nderiv  > 0)) {
  36.   
  37.                   /*
  38.                    * The edge has positive slope
  39. ***************
  40. *** 999,1005
  41.       u_char       *line;
  42.       int           curr_line;
  43.       int           scanline;
  44. !     int           y, next_edge;
  45.       Color        *pixel_color;
  46.       Color         sum;
  47.       int           i, j, k;
  48.  
  49. --- 1001,1007 -----
  50.       u_char       *line;
  51.       int           curr_line;
  52.       int           scanline;
  53. !     int           y, next_edge, y_limit;
  54.       Color        *pixel_color;
  55.       Color         sum;
  56.       int           i, j, k;
  57. ***************
  58. *** 1038,1044
  59.           }
  60.       }
  61.   
  62. !     y = yres - 1;
  63.       active_list = NULL;
  64.       curr_line = 0;
  65.       scanline = 0;
  66.  
  67. --- 1040,1054 -----
  68.           }
  69.       }
  70.   
  71. !     if (reverse_scan) {
  72. !         y = 0;
  73. !         y_limit = yres;
  74. !         scanline =  (yres - 1) * oversampl;
  75. !     } else {
  76. !         y = yres - 1;
  77. !         y_limit = -1;
  78. !         scanline =  0;
  79. !     }
  80.       active_list = NULL;
  81.       curr_line = 0;
  82.   
  83. ***************
  84. *** 1041,1049
  85.       y = yres - 1;
  86.       active_list = NULL;
  87.       curr_line = 0;
  88. -     scanline = 0;
  89. -  
  90. -     while (y >= 0) {
  91.   
  92.           active_list = merge_edge_lists(active_list, y_bucket[y]);
  93.           y_bucket[y] = NULL;
  94.  
  95. --- 1051,1056 -----
  96.       }
  97.       active_list = NULL;
  98.       curr_line = 0;
  99.   
  100.       while (y != y_limit) {
  101.   
  102. ***************
  103. *** 1045,1050
  104.    
  105.       while (y >= 0) {
  106.   
  107.           active_list = merge_edge_lists(active_list, y_bucket[y]);
  108.           y_bucket[y] = NULL;
  109.           next_edge = y - 1;
  110.  
  111. --- 1052,1059 -----
  112.       active_list = NULL;
  113.       curr_line = 0;
  114.   
  115. +     while (y != y_limit) {
  116. + 
  117.           active_list = merge_edge_lists(active_list, y_bucket[y]);
  118.           y_bucket[y] = NULL;
  119.   
  120. ***************
  121. *** 1047,1053
  122.   
  123.           active_list = merge_edge_lists(active_list, y_bucket[y]);
  124.           y_bucket[y] = NULL;
  125. -         next_edge = y - 1;
  126.   
  127.           while (next_edge >=0 && y_bucket[next_edge] == NULL)
  128.               next_edge--;
  129.  
  130. --- 1056,1061 -----
  131.   
  132.           active_list = merge_edge_lists(active_list, y_bucket[y]);
  133.           y_bucket[y] = NULL;
  134.   
  135.           if (reverse_scan) {
  136.               next_edge = y + 1;
  137. ***************
  138. *** 1049,1058
  139.           y_bucket[y] = NULL;
  140.           next_edge = y - 1;
  141.   
  142. !         while (next_edge >=0 && y_bucket[next_edge] == NULL)
  143. !             next_edge--;
  144. !         while (y > next_edge) {
  145. ! 
  146.               if (field == BOTH || (scanline & 1) == field) {
  147.                   buffer_clear(xres, linebuf[curr_line]);
  148.                   render_scanline(xres, linebuf[curr_line], 
  149.  
  150. --- 1057,1073 -----
  151.           active_list = merge_edge_lists(active_list, y_bucket[y]);
  152.           y_bucket[y] = NULL;
  153.   
  154. !         if (reverse_scan) {
  155. !             next_edge = y + 1;
  156. !             while (next_edge < y_limit && y_bucket[next_edge] == NULL)
  157. !                 next_edge++;
  158. !         } else {
  159. !             next_edge = y - 1;
  160. !             while (next_edge >= 0 && y_bucket[next_edge] == NULL)
  161. !                 next_edge--;
  162. !         }
  163. !         while ((reverse_scan    && (y < next_edge)) ||
  164. !                ((!reverse_scan) && (y > next_edge))) {
  165.               if (field == BOTH || (scanline & 1) == field) {
  166.                   buffer_clear(xres, linebuf[curr_line]);
  167.                   render_scanline(xres, linebuf[curr_line], 
  168. ***************
  169. *** 1096,1102
  170.                   }
  171.   
  172.                   curr_line = 0;
  173. !                 scanline++;
  174.               }
  175.               
  176.           if (active_list != NULL) {
  177.  
  178. --- 1111,1117 -----
  179.                   }
  180.   
  181.                   curr_line = 0;
  182. !                 scanline += reverse_scan ? -1 : 1;
  183.               }
  184.               
  185.           if (active_list != NULL) {
  186. ***************
  187. *** 1104,1110
  188.               edgep2 = active_list;
  189.               edgep = active_list->next;
  190.               while (edgep != NULL) {
  191. !                 if (edgep->ystart <= (edgep->ystop + 1)) {
  192.                           edgep2->next = edgep->next;
  193.                   sfree(edgep);
  194.                       edgep = edgep2->next;
  195.  
  196. --- 1119,1128 -----
  197.               edgep2 = active_list;
  198.               edgep = active_list->next;
  199.               while (edgep != NULL) {
  200. !                 if ((reverse_scan &&
  201. !                          edgep->ystart >= (edgep->ystop - 1)) ||
  202. !                         ((!reverse_scan) &&
  203. !                          edgep->ystart <= (edgep->ystop + 1))) {
  204.                           edgep2->next = edgep->next;
  205.                   sfree(edgep);
  206.                       edgep = edgep2->next;
  207. ***************
  208. *** 1114,1120
  209.               }
  210.                   }
  211.                   
  212. !               if (active_list->ystart <= (active_list->ystop + 1)) {
  213.                   edgep = active_list;
  214.               active_list = active_list->next;
  215.                   sfree(edgep);
  216.  
  217. --- 1132,1141 -----
  218.               }
  219.                   }
  220.                   
  221. !               if ((reverse_scan && 
  222. !                      active_list->ystart >= (active_list->ystop - 1)) ||
  223. !                     ((!reverse_scan) &&
  224. !                      active_list->ystart <= (active_list->ystop + 1))) {
  225.                   edgep = active_list;
  226.               active_list = active_list->next;
  227.                   sfree(edgep);
  228. ***************
  229. *** 1122,1128
  230.                   
  231.               edgep = active_list;
  232.               while (edgep != NULL) {
  233. !                 edgep->ystart--;
  234.               edgep->xstart += edgep->xstep;
  235.                       edgep->hden += edgep->hdenstep;
  236.                       if (render_mode != FLAT) {
  237.  
  238. --- 1143,1149 -----
  239.                   
  240.               edgep = active_list;
  241.               while (edgep != NULL) {
  242. !                 edgep->ystart += reverse_scan ? 1 : -1;
  243.               edgep->xstart += edgep->xstep;
  244.                       edgep->hden += edgep->hdenstep;
  245.                       if (render_mode != FLAT) {
  246. ***************
  247. *** 1138,1144
  248.               edgep = edgep->next;
  249.               }
  250.           }
  251. !             y--;
  252.       }
  253.       }
  254.       sfree(line);
  255.  
  256. --- 1159,1165 -----
  257.               edgep = edgep->next;
  258.               }
  259.           }
  260. !             y += reverse_scan ? 1 : -1;
  261.       }
  262.       }
  263.       sfree(line);
  264. ***************
  265. *** 1353,1359
  266.   {
  267.       Edge            *active_list;
  268.       Edge            *edgep, *edgep2;
  269. !     int              y, next_edge;
  270.       
  271.       y = depthmap_size - 1;
  272.       active_list = NULL;
  273.  
  274. --- 1374,1380 -----
  275.   {
  276.       Edge            *active_list;
  277.       Edge            *edgep, *edgep2;
  278. !     int              y, next_edge, y_limit;
  279.       
  280.       if (reverse_scan) {
  281.           y = 0;
  282. ***************
  283. *** 1355,1361
  284.       Edge            *edgep, *edgep2;
  285.       int              y, next_edge;
  286.       
  287. !     y = depthmap_size - 1;
  288.       active_list = NULL;
  289.    
  290.       while (y >= 0) {
  291.  
  292. --- 1376,1388 -----
  293.       Edge            *edgep, *edgep2;
  294.       int              y, next_edge, y_limit;
  295.       
  296. !     if (reverse_scan) {
  297. !         y = 0;
  298. !         y_limit = depthmap_size;
  299. !     } else {
  300. !         y = depthmap_size - 1;
  301. !         y_limit = -1;
  302. !     }
  303.       active_list = NULL;
  304.    
  305.       while (y != y_limit) {
  306. ***************
  307. *** 1358,1364
  308.       y = depthmap_size - 1;
  309.       active_list = NULL;
  310.    
  311. !     while (y >= 0) {
  312.   
  313.           active_list = merge_edge_lists(active_list, y_bucket[y]);
  314.           y_bucket[y] = NULL;
  315.  
  316. --- 1385,1391 -----
  317.       }
  318.       active_list = NULL;
  319.    
  320. !     while (y != y_limit) {
  321.   
  322.           active_list = merge_edge_lists(active_list, y_bucket[y]);
  323.           y_bucket[y] = NULL;
  324. ***************
  325. *** 1364,1371
  326.           y_bucket[y] = NULL;
  327.           next_edge = y - 1;
  328.   
  329. !         while (next_edge >=0 && y_bucket[next_edge] == NULL)
  330. !             next_edge--;
  331.   
  332.           while (y > next_edge) {
  333.   
  334.  
  335. --- 1391,1405 -----
  336.           y_bucket[y] = NULL;
  337.           next_edge = y - 1;
  338.   
  339. !         if (reverse_scan) {
  340. !             next_edge = y + 1;
  341. !             while (next_edge < y_limit && y_bucket[next_edge] == NULL)
  342. !                 next_edge++;
  343. !         } else {
  344. !             next_edge = y - 1;
  345. !             while (next_edge >= 0 && y_bucket[next_edge] == NULL)
  346. !                 next_edge--;
  347. !         }
  348.   
  349.           while ((reverse_scan    && (y < next_edge)) ||
  350.                  ((!reverse_scan) && (y > next_edge))) {
  351. ***************
  352. *** 1367,1373
  353.           while (next_edge >=0 && y_bucket[next_edge] == NULL)
  354.               next_edge--;
  355.   
  356. !         while (y > next_edge) {
  357.   
  358.               render_dmap_line(d_map + (depthmap_size - 1 - y) * depthmap_size, 
  359.                                active_list); 
  360.  
  361. --- 1401,1408 -----
  362.                   next_edge--;
  363.           }
  364.   
  365. !         while ((reverse_scan    && (y < next_edge)) ||
  366. !                ((!reverse_scan) && (y > next_edge))) {
  367.   
  368.               render_dmap_line(d_map + (depthmap_size - 1 - y) * depthmap_size, 
  369.                                active_list); 
  370. ***************
  371. *** 1377,1383
  372.               edgep2 = active_list;
  373.               edgep = active_list->next;
  374.               while (edgep != NULL) {
  375. !                 if (edgep->ystart <= (edgep->ystop + 1)) {
  376.                           edgep2->next = edgep->next;
  377.                   sfree(edgep);
  378.                       edgep = edgep2->next;
  379.  
  380. --- 1412,1421 -----
  381.               edgep2 = active_list;
  382.               edgep = active_list->next;
  383.               while (edgep != NULL) {
  384. !                 if ((reverse_scan &&
  385. !                          edgep->ystart >= (edgep->ystop - 1)) ||
  386. !                         ((!reverse_scan) &&
  387. !                          edgep->ystart <= (edgep->ystop + 1))) {
  388.                           edgep2->next = edgep->next;
  389.                   sfree(edgep);
  390.                       edgep = edgep2->next;
  391. ***************
  392. *** 1387,1393
  393.               }
  394.                   }
  395.                   
  396. !               if (active_list->ystart <= (active_list->ystop + 1)) {
  397.                   edgep = active_list;
  398.               active_list = active_list->next;
  399.                   sfree(edgep);
  400.  
  401. --- 1425,1434 -----
  402.               }
  403.                   }
  404.                   
  405. !               if ((reverse_scan && 
  406. !                      active_list->ystart >= (active_list->ystop - 1)) ||
  407. !                     ((!reverse_scan) &&
  408. !                      active_list->ystart <= (active_list->ystop + 1))) {
  409.                   edgep = active_list;
  410.               active_list = active_list->next;
  411.                   sfree(edgep);
  412. ***************
  413. *** 1395,1401
  414.                   
  415.               edgep = active_list;
  416.               while (edgep != NULL) {
  417. !                 edgep->ystart--;
  418.               edgep->xstart += edgep->xstep;
  419.                       edgep->hden += edgep->hdenstep;
  420.               edgep = edgep->next;
  421.  
  422. --- 1436,1442 -----
  423.                   
  424.               edgep = active_list;
  425.               while (edgep != NULL) {
  426. !                 edgep->ystart += reverse_scan ? 1 : -1;
  427.               edgep->xstart += edgep->xstep;
  428.                       edgep->hden += edgep->hdenstep;
  429.               edgep = edgep->next;
  430. ***************
  431. *** 1401,1407
  432.               edgep = edgep->next;
  433.               }
  434.           }
  435. !             y--;
  436.       }
  437.       }
  438.   }
  439.  
  440. --- 1442,1448 -----
  441.               edgep = edgep->next;
  442.               }
  443.           }
  444. !             y += reverse_scan ? 1 : -1;
  445.       }
  446.       }
  447.   }
  448. ***************
  449. *** 1591,1596
  450.   /*============= Functions that handles global initializations==============*/
  451.   
  452.   /*
  453.    * If called with TRUE as argument, no backface culling will 
  454.    * be performed. If a polygon is backfacing it will be rendered
  455.    * as facing in the opposit direction.
  456.  
  457. --- 1632,1648 -----
  458.   /*============= Functions that handles global initializations==============*/
  459.   
  460.   /*
  461. +  * If the argument is TRUE, render the scanlines in reverse.
  462. +  */
  463. + void
  464. + sipp_render_direction (flag)
  465. +     bool flag;
  466. + {
  467. +     reverse_scan = flag;
  468. + /*    reverse_scan = FALSE; /**/
  469. + }
  470. + 
  471. + /*
  472.    * If called with TRUE as argument, no backface culling will 
  473.    * be performed. If a polygon is backfacing it will be rendered
  474.    * as facing in the opposit direction.
  475. ***************
  476. *** 1648,1652
  477.       camera_init();
  478.       sipp_show_backfaces(FALSE);
  479.       sipp_shadows(FALSE, 0);
  480.       sipp_background(0.0, 0.0, 0.0);
  481.   }
  482.  
  483. --- 1700,1705 -----
  484.       camera_init();
  485.       sipp_show_backfaces(FALSE);
  486.       sipp_shadows(FALSE, 0);
  487. +     sipp_render_direction(FALSE);
  488.       sipp_background(0.0, 0.0, 0.0);
  489.   }
  490.